Representing Code History with Development Environment Events

Modern development environments handle information about the intent of the programmer: for example, they use abstract syntax trees for providing high-level code manipulation such as refactorings; nevertheless, they do not keep track of this information in a way that would simplify code sharing and change understanding. In most Smalltalk systems, source code modifications are immediately registered in a transaction log often called a ChangeSet. Such mechanism has proven reliability, but it has several limitations. In this paper we analyse such limitations and describe scenarios and requirements for tracking fine-grained code history with a semantic representation. We present Epicea, an early prototype implementation. We want to enrich code sharing with extra information from the IDE, which will help understanding the intention of the changes and let a new generation of tools act in consequence

Semantics and Security Issues in JavaScript

There is a plethora of research articles describing the deep semantics of JavaScript. Nevertheless, such articles are often difficult to grasp for readers not familiar with formal semantics. In this report, we propose a digest of the semantics of JavaScript centered around security concerns. This document proposes an overview of the JavaScript language and the misleading semantic points in its design. The first part of the document describes the main characteristics of the language itself. The second part presents how those characteristics can lead to problems. It finishes by showing some coding patterns to avoid certain traps and presents some ECMAScript 5 new features.Comment: Deliverable Resilience FUI 12: 7.3.2.1 Failles de s\'ecurit\'e en JavaScript / JavaScript security issue

Towards a new package dependency model

International audienceSmalltalk originally did not have a package manager. Each Smalltalk implementation defined its own with more or less functionalities. Since 2010, Monticello/Metacello[Hen09] one package manager is available for open-source Smalltalks. It allows one to load source code packages with their dependencies. This package manager does not have all features we can find in well-known package managers like those used for the Linux operating system. This paper tries to identify the missing features and proposes solution to reach a full-featured package manager. A part of this solution is to repre-sent packages and dependencies as first-class objects, leading to the definition of a new dependency model

Challenges to support automated random testing for dynamically typed languages

International audienceAutomated random testing is a proven way to identify bugs and precondition violations, and this even in well tested libraries. In the context of statically typed languages, current automated random testing tools heavily take advantage of static method declaration (argument types, thrown exceptions) to constrain input domains while testing and to identify errors. For such reason, automated random testing has not been investigated in the context of dynamically typed languages. In this paper we present the key challenges that have to be addressed to support automated testing in dynamic languages

De l'importance des plans d'interaction dans la géométrie interactive

International audienceInteractive geometry environments support creation and exploitation of geometric sketches. However, such environments are often driven in a rigid manner, following a well specified construction path. This rigidity is not always compatible with the internal cognitive representation of the learner about the geometric domain. This rigidity is therefore a source of internal tension for the learner and it can reduce the pedagogical added value of these environments. We think addi- tional interactive planes to manipulate a geometric sketch differently can help the learner. We have developed an interactive geometry framework that is able to receive additional interactive planes such as a free sketching and a command-based one. We have experimented it in a junior high school class and we report here our results.Les environnements de géométrie interactive permettent créations et explorations de figures géométriques. Ceux-ci imposent cependant à l'apprenant un formalisme fort lors de la construction d'une figure. Cette rigidité n'est pas toujours compatible avec la représentation cognitive de l'ap- prenant du domaine d'apprentissage. Elle est donc source de tensions internes chez celui-ci et peut réduire la portée pédagogique de ces environnements. Nous pensons que des plans d'interaction supplémentaires pour manipuler différemment une même figure géométrique peuvent aider l'appre- nant. Nous avons ainsi développé un framework de géométrie interactive permettant l'ajout de tels plans puis nous avons expérimenté son utilisation dans une classe de 3e

Pragmas: Literal Messages as Powerful Method Annotations

International audienceOften tools need to be extended at runtime depending on the availability of certain features. Simple registration mechanisms can handle such a situation: It often boils down to represent an action and describe such action with some meta-data. However, ad-hoc registration mechanisms have some drawbacks: they are often not uniform and do not fit well with code navigability. In addition, metadata is not automatically synchronized with the data or behavior it describes. In this article we present the notion of pragmas, method annotations , as it was introduced in VisualWorks and now it is an important extensibility mechanism of Pharo. We present some examples of pragmas within Pharo

Toward a modularization of Pharo: Analysis of the design space for a new module system.

International audienceSmalltalk is a fully reflexive object-oriented programming language created in the early 70's. Over the years, it has been influencing many other programming languages and evolved into many variants. However, it has no notion of visibility, providing a single namespace. Because all classes and global variables were visible from every point of the system, numerous dependencies appeared and it turned into a monolithic system. As a descendant of Smalltalk, Pharo should provide a programming construct to make the platform more modular. Designing such a construct is a challenge because of two migration constraints: it must support circular dependencies and local class extensions. In this context, this article present an analysis of the design space for a module system through three design axis: encapsulation, dependency resolution, and module combination

Assessing the Quality of your Software with MoQam

International audienceOver the last decade, the need for quality in software has increased. Several quality models have been proposed [4, 6, 11]. These mod- els emphasize the need to have quality checks while developing a software program. As far as we are aware of, no model to assess quality of existing software have reached a significant acceptance. This paper describes the Qualixo quality model. Qualixo is an open-source quality model developed by several companies and pushed further in the context of the Squale research project. Ac- cording to Marinescu and Ratiu [9], Qualixo can be classified as a Factor-Criteria-Metrics quality model. Qualixo is being applied in large companies such as AirFrance or PSA. It uses measurements to assess software quality. These measurements cover a number of different aspects of a software, including specification accuracy, programming rules, and test coverage. Qualixo has been origi- nally implemented on top of Eclipse. In this paper we present Mo- Qam (Moose Quality Assessment Model), the implementation of the Qualixo quality model in the Moose open-source reengineering environment

A Process-Oriented Software Architecture Reconstruction Taxonomy

International audienceTo maintain and understand large applications, it is cru- cial to know their architecture. The first problem is that architectures are not explicitly represented in the code as classes and packages are. The second problem is that suc- cessful applications evolve over time so their architecture inevitably drifts. Reconstructing and checking whether the architecture is still valid is thus an important aid. While there is a plethora of approaches and techniques supporting architecture reconstruction, there is no comprehensive state of the art and it is often difficult to compare the ap- proaches. This article presents a first state of the art in soft- ware architecture reconstruction, with the desire to support the understanding of the field

Proposals for the Reborn Pharo Developer

International audienceSmalltalk was at the birth of current IDEs. Current Smalltalk IDEs, however, lost their abilities to adapt to developer needs (edit and jump, back button, auto-completion,...). Therefore while offering a powerful sets of tools current Smalltalk IDEs looks clunky and often lacks the application of a consistent set of guidelines. In this paper we sketch some possible IDEs future features or reorganization